package com.llb666.java.thread;

/**
 *
 死锁条件
 互斥使用：一个资源只能分配给一个线程
 不可剥夺：资源只能由占有者释放，申请者不能强制剥夺
 请求保持：线程申请资源时，保持对原有资源的占有
 循环等待：存在一个进程等待队列：{P1 , P2 , … , Pn}, 其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，形成一个进程等待环路
 代码
 思路
 定义两个资源o1，o2
 对象deadLock1占有资源o1，需要资源o2
 对象deadLock2占有资源o2，需要资源o1
 死锁产生
 * @author Administrator
 *
 */
public class DeadLock{
    // 共享变量 1
    private static final Object share1 = new Object();
    // 共享变量 2
    private static final Object share2 = new Object();

    public static void testDeadLock() throws InterruptedException {
        // 初始化线程 1，线程 1 需要在锁定 share1 共享资源的情况下再锁定 share2
        Thread thread1 = new Thread(() -> {
            synchronized (share1){
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (share2){
                    System.out.println(Thread.currentThread().getName()+ "is run");
                }
            }
        });

        // 初始化线程 2，线程 2 需要在锁定 share2 共享资源的情况下再锁定 share1
        Thread thread2 = new Thread(() -> {
            synchronized (share2){
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (share1){
                    System.out.println(Thread.currentThread().getName()+ "is run");
                }
            }
        });
        // 当线程 1、2 启动后，都在等待对方锁定的资源，但都得不到，造成死锁
        thread1.start();
        thread2.start();
        Thread.sleep(1000000000);
    }

    public static void main(String[] args) throws InterruptedException {
        testDeadLock();
    }
}